🐍 Hello, World! in Different Ways (Python)

. Each example includes a short explanation.

This notebook demonstrates multiple creative ways to print "Hello, World!" in Python

1️⃣ Classic Print

The standard and most common way to print text in Python. print("Hello, World!") Hello, World!

2️⃣ Single Quotes

Python allows both single and double quotes for strings. print('Hello, World!') Hello, World!

3️⃣ Using a Variable

Store the message in a variable before printing. msg = "Hello, World!" print(msg) Hello, World!

4️⃣ String Concatenation

Combine multiple strings using the + operator. print("Hello, " + "World!") Hello, World!

5️⃣ Using join()

Join multiple strings from a list into one string. print("".join(["Hello", ", ", "World!"])) Hello, World!

6️⃣ f-String

Use formatted string literals (modern and recommended way). text = "World" print(f"Hello, {text}!") Hello, World!

7️⃣ format() Method

Older but still widely used string formatting method. print("Hello, {}!".format("World")) Hello, World!

8️⃣ Using sep Parameter

Customize how print separates multiple values. print("Hello", "World!", sep=", ") Hello, World!

9️⃣ List Unpacking

Unpack list elements directly into print function. print(*["Hello,", "World!"]) Hello, World!

🔟 Using ASCII Values

Construct the string using ASCII character codes.

print(chr(72)+chr(101)+chr(108)+chr(108)+chr(111)+",

"+chr(87)+chr(111)+chr(114)+chr(108)+chr(100)+"!") Hello, World!

1️⃣1️⃣ Lambda Function

Print using an anonymous (lambda) function. (lambda x: print(x))("Hello, World!") Hello, World!

1️⃣2️⃣ sys.stdout.write()

Directly write output to standard output stream. import sys sys.stdout.write("Hello, World!") Hello, World!

🔹 import sys sys is a built-in Python module. It provides access to system-level functions and variables. One important object inside it is stdout. Think of it like this: sys → system tools stdout → standard output (your screen / console) 🔹 What is sys.stdout? stdout means standard output stream It’s where Python sends output by default When you use print(), Python internally writes to sys.stdout

1️⃣3️⃣ Custom Function

Define and call your own function to print the message. def hi(): print("Hello, World!") hi() Hello, World!

Read More

Python Coding challenge - Day 483| What is the output of the following Python Code?

 

Code Explanation:

1. Global Scope (x = 10)

x = 10

The first x = 10 creates a variable x in the global scope (outside any function).

This value of x is available throughout the entire program unless overridden in a local scope.

2. Defining outer()

def outer():

    x = 20

    def inner(): nonlocal x; x = 30

    inner(); print(x)

Inside outer(), there's another variable x = 20, which is local to outer(). This means that x inside the outer() function initially takes the value 20.

Defining the inner() function:

def inner(): nonlocal x; x = 30

inner() is a nested function inside outer().

The nonlocal x statement tells Python to look for x in the nearest enclosing scope (which is outer()), rather than creating a new x in inner().

The x = 30 changes the value of x in the enclosing outer() function to 30.

Calling inner():

inner(); print(x)

When inner() is called, it updates the value of x in the outer() function to 30.

After inner() runs, x inside outer() is now 30.

The print(x) inside outer() will print the value of x from the outer() scope, which is now 30.

3. Calling outer()

outer(); print(x)

Executing outer():

outer() is called, and inside it, x becomes 20 initially.

inner() runs and modifies x to 30.

So, the first print statement inside outer() prints 30.

The final print(x):

This print statement is outside outer(), so it refers to the global x.

The global x was never modified by outer(). It still holds the value 10.

Hence, this print statement prints 10.

Final Output

30

10

Read More

Python Coding challenge - Day 457| What is the output of the following Python Code?

 

Code Explanation:

 1. Importing defaultdict

from collections import defaultdict

This imports the defaultdict class from Python's collections module.

defaultdict is like a regular dictionary but provides a default value for missing keys.

2. Creating the defaultdict

d = defaultdict(int)

int is passed as the default factory function.

When you try to access a missing key, defaultdict automatically creates it with the default value of int(), which is 0.

3. Incrementing Values

d['a'] += 1

'a' does not exist yet in d, so defaultdict creates it with value 0.

Then, 0 + 1 = 1, so d['a'] becomes 1.

d['b'] += 2

Similarly, 'b' is missing, so it's created with value 0.

Then 0 + 2 = 2, so d['b'] becomes 2.

 4. Printing the Dictionary

print(d)

Outputs: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

This shows a dictionary-like structure with keys 'a' and 'b' and their respective values.

 Final Output

{'a': 1, 'b': 2}

Read More

Python Coding challenge - Day 455| What is the output of the following Python Code?

 

Code Explanation:

1. Class Definition

class MyClass:

This line defines a class named MyClass.

A class is used to create objects that have data and behavior.

2. Constructor Method __init__

def __init__(self, x):

    self.x = x

__init__ is the constructor method.

It runs automatically when you create an object from the class.

It initializes the object's x attribute with the value you pass during object creation.

3. Incorrect Indentation of __call__

   def __call__(self, y):

        return self.x + y

It should be at the same level as __init__, not inside it.

4. Creating an Object

obj = MyClass(10)

Creates an object obj of MyClass.Passes 10 to the constructor, so self.x = 10.

5. Calling the Object

print(obj(5))

Calls the object obj with argument 5.

Python executes obj.__call__(5).

Inside __call__, it returns self.x + y, which is 10 + 5 = 15.

print displays 15.

Final Output

15

Read More

Python Coding challenge - Day 454| What is the output of the following Python Code?

 

Code Explanation:

1. Class Definition

class MyCallable:

This line defines a class named MyCallable.

A class is a blueprint for creating objects.

2. Special Method __call__

def __call__(self, x):

Defines a special method inside the class.

__call__ allows an object to be called like a function.

It takes self (the object itself) and x (an input value) as parameters.

3. Return Statement

return x * 2

This line returns the result of x * 2.

It doubles the input value x.

4. Creating an Object

obj = MyCallable()

Creates an instance (object) obj of the MyCallable class.

5. Calling the Object like a Function

print(obj(3))

Calls the object obj with argument 3.

Internally, Python automatically runs obj.__call__(3).

3 * 2 is calculated, which equals 6.

The print function prints the output 6.

Final Output

6

Read More

Python Coding challenge - Day 452| What is the output of the following Python Code?

 

Code Explanation:

Function Decorator Definition

def multiply(func):

    return lambda x: func(x) * 3

This is a decorator named multiply.

It takes a function func as input.

It returns a new lambda function:

lambda x: func(x) * 3

→ This means it calls the original function func(x) and multiplies the result by 3.

Decorating the add Function

@multiply

def add(x):

    return x + 2

The @multiply decorator wraps the add function.

So add(x) becomes:

lambda x: (x + 2) * 3

 Calling the Function

print(add(5))

When add(5) is called:

First: 5 + 2 = 7

Then: 7 * 3 = 21

So the result is 21.

Final Output

21

Read More

Python Coding challenge - Day 449| What is the output of the following Python Code?

 

Code Explanation:

 Importing Modules

import csv

from io import StringIO

Explanation:

csv is Python’s built-in module to read/write CSV files.

StringIO lets us treat a string like a file (needed because csv expects a file-like object).

Creating CSV Data

python

Copy

Edit

data = "a,b\n1,2\n3,4"

Explanation:

A string representing CSV content:

a,b      ← header row

1,2      ← first data row

3,4      ← second data row

Reading CSV with DictReader

reader = csv.DictReader(StringIO(data))

Explanation:

Wraps the string in StringIO to act like a file.

csv.DictReader reads each row as a dictionary using the first row as keys.

Example:

next(reader)  ➞ {'a': '1', 'b': '2'}

Getting a Field Value

print(next(reader)['b'])

Explanation:

next(reader) gets the first data row: {'a': '1', 'b': '2'}

['b'] accesses the value for column 'b', which is '2'.

So it prints:

2

Final Output:

2

Read More

Python Coding challenge - Day 453| What is the output of the following Python Code?

 

Code Explanation:

Importing the Threading Module

import threading

This imports Python's built-in threading module, which is used for creating and managing threads.

Defining the Function

def add_numbers(x, y):

    print(x + y)

A simple function that takes two numbers, adds them, and prints the result.

Creating a Thread

t = threading.Thread(target=add_numbers, args=(5, 7))

Thread() creates a new thread object.

target=add_numbers means the function add_numbers will be run by the thread.

args=(5, 7) passes the arguments 5 and 7 to the function.

Starting the Thread

t.start()

This starts the thread.

It begins executing the add_numbers function in parallel with the main program.

It prints 12 (because 5 + 7 = 12).

Waiting for the Thread to Finish

t.join()

This makes the main thread wait until the child thread t completes execution.

Ensures that the program doesn't exit before the thread finishes.

Final Output

12

Read More

Python Coding challenge - Day 451| What is the output of the following Python Code?

 Code Explanation:

1. Defining the Class

class Magic:

What it does: Starts a class definition named Magic.

2. Overriding __bool__

    def __bool__(self): return False

What it does: Overrides the __bool__() special method.

Purpose: This method defines the "truthiness" of an instance when passed to bool() or used in conditions like if m.

Return value: Always returns False, so the object will be treated as False in boolean contexts.

3. Overriding __len__

    def __len__(self): return 1

What it does: Overrides the __len__() special method.

Purpose: Defines what should be returned when len(m) is called.

Return value: Always returns 1.

 

4. Creating an Instance

m = Magic()

What it does: Creates an instance of the Magic class and stores it in the variable m.

5. Printing the Results

print(bool(m), len(m))

bool(m):

Since __bool__ is defined and returns False, this evaluates to False.

len(m):

This calls the __len__() method, which returns 1.

Final Output:

False 1

Read More

Python Coding challenge - Day 450| What is the output of the following Python Code?

 

Code Explanation:

 Importing the LRU Cache Decorator

from functools import lru_cache

What it does: Imports the lru_cache decorator from the functools module.

Why it's used: lru_cache (Least Recently Used cache) stores results of expensive function calls and returns the cached result when the same inputs occur again. This is useful for optimizing recursive functions like Fibonacci.

Decorating the Function with Cache

@lru_cache(maxsize=3)

What it does: Applies the lru_cache to the function that follows.

Parameter: maxsize=3 limits the cache to store only the 3 most recently used results. Older values are discarded when the cache is full.

Why it's important: Reduces redundant calculations in recursion.

Defining the Fibonacci Function

def fib(n):

What it does: Starts the definition of the Fibonacci function.

Parameter: n is the position in the Fibonacci sequence to calculate.

Handling the Base Case

    if n < 2:

        return n

What it does: Handles the base case of the recursion.

Explanation:

If n is 0 → return 0

If n is 1 → return 1

These are the first two numbers in the Fibonacci sequence.

Recursive Case

    return fib(n-1) + fib(n-2)

What it does: Calls fib recursively to calculate the nth Fibonacci number.

How it works:

For n ≥ 2, Fibonacci is defined as:

fib(n) = fib(n-1) + fib(n-2)

This adds the two preceding Fibonacci numbers.

Calling the Function and Printing the Result

print(fib(5))

What it does: Calls fib(5) and prints the result.

 Final Output: 5

This is the 5th number in the Fibonacci sequence (0-based indexing):

0, 1, 1, 2, 3, 5

Read More

Python Coding challenge - Day 448| What is the output of the following Python Code?

Code Explanation: 

Importing Modules

import tokenize

from io import BytesIO

Explanation:

tokenize is used to break Python code into tokens.

BytesIO allows byte strings to behave like file objects, which tokenize needs.

Defining Code as Bytes

code = b"x = 1 + 2"

Explanation:

Defines the Python code as a byte string.

tokenize requires the input in bytes format.

Tokenizing the Code

tokens = list(tokenize.tokenize(BytesIO(code).readline))

Explanation:

Converts the byte string into a stream with BytesIO.

Feeds the line reader into tokenize.tokenize() to get tokens.

Converts the token generator into a list.

Accessing a Specific Token

print(tokens[2].string)

Explanation:

Accesses the third token (index 2), which is '='.

string gets the literal string value of the token.

Prints '='.

Final Output:

=

Read More

Python Coding challenge - Day 445| What is the output of the following Python Code?

 

Code Explanation:

 1. Importing the bisect module

import bisect

This imports Python’s bisect module, which is used for working with sorted lists.

It provides support for:

Finding the insertion point for a new element while maintaining sort order.

Inserting the element in the correct place.

2. Creating a sorted list

lst = [1, 3, 4]

This is your initial sorted list.

It must be sorted in ascending order for the bisect functions to work correctly.

3. Inserting 2 in order

bisect.insort(lst, 2)

insort() inserts the element 2 into the correct position to maintain the sorted order.

It does binary search behind the scenes to find the right spot (efficient).

Resulting list becomes:

lst → [1, 2, 3, 4]

4. Printing the result

print(lst)

This prints the updated list after the insertion.

Output:

[1, 2, 3, 4]

Read More

Python Coding challenge - Day 444| What is the output of the following Python Code?

 

Code Explanation:

import heapq

Purpose: This line imports Python’s built-in heapq module.

What it does: heapq provides an implementation of the heap queue algorithm, also known as a priority queue.

Note: Heaps in Python using heapq are min-heaps, meaning the smallest element is always at the root (index 0 of the list).

Initialize a list

h = [5, 8, 10]

Purpose: Create a regular list h containing three integers: 5, 8, and 10.

Note: At this point, h is just a plain list — not a heap yet.

Convert the list into a heap

heapq.heapify(h)

Purpose: Transforms the list h into a valid min-heap in-place.

Result: After heapifying, the smallest element moves to index 0.

For h = [5, 8, 10], it's already a valid min-heap, so the structure doesn't visibly change:

h → [5, 8, 10]

Push and Pop in one step

print(heapq.heappushpop(h, 3))

Purpose: Pushes the value 3 into the heap, then immediately pops and returns the smallest item from the heap.

What happens:

Push 3 → temporary heap is [3, 5, 10, 8]

Pop the smallest item → 3 is the smallest, so it's popped.

Final heap → [5, 8, 10] (same as before)

Return value: The popped value, which is 3, is printed.

Final Output:

3

Read More

Python Coding challenge - Day 443| What is the output of the following Python Code?

Code Explanation:

Line 1:

from itertools import groupby

This imports the groupby function from Python’s built-in itertools module.

groupby is used to group consecutive elements in an iterable (like a list) that are the same.

Line 2:

nums = [1, 1]

This creates a list called nums containing two elements: [1, 1].

Both elements are the same and are next to each other — this is important for groupby.

Line 3:

groups = [(k, list(g)) for k, g in groupby(nums)]

This line uses list comprehension to group the items. Let's break it into parts:

groupby(nums):

Looks at the list from left to right.

Groups consecutive elements that are the same.

In this case, 1 and 1 are next to each other, so they’re grouped into one group.

For each group:

k is the value being grouped (in this case, 1)

g is a generator (iterator) over the group of matching values

 list(g):

Converts the group iterator g into an actual list, so we can see the contents.

So the comprehension becomes:

groups = [(1, [1, 1])]

Line 4:

print(groups)

This prints the final result.

Final Output:

[(1, [1, 1])]

 

Read More

Python Coding challenge - Day 442| What is the output of the following Python Code?

 

Code Explanation:

Line 1

import torch

This imports the PyTorch library.

PyTorch is a powerful library for tensor computations and automatic differentiation, often used in deep learning.

Line 2

x = torch.tensor(2.0, requires_grad=True)

Creates a tensor x with the value 2.0.

requires_grad=True tells PyTorch:

“Please keep track of all operations involving this tensor.”

So later, we can calculate gradients (i.e., derivatives) with respect to x.

Line 3

y = x**3 + 2 * x + 1

Defines a function y in terms of x:

Since x has requires_grad=True, PyTorch builds a computation graph behind the scenes.

Every operation (**3, *2, +1) is tracked so we can differentiate y later.

 Line 4

y.backward()

This tells PyTorch to compute the derivative of y with respect to x.

Since y is a scalar (a single value), calling .backward() automatically computes:

Line 5

print(x.grad)

Prints the computed gradient of y with respect to x.

Final Output:

tensor(14.)

Read More

Python Coding challenge - Day 441| What is the output of the following Python Code?

 

Code Explanation:

1. Import Necessary Libraries

from sklearn.tree import DecisionTreeClassifier

import numpy as np

DecisionTreeClassifier: This is an implementation of a decision tree algorithm used for classification tasks. It learns from labeled data (X, y) and can make predictions based on the learned rules.

numpy: numpy is used to handle arrays, which are commonly used for data manipulation and storage. Here, it's used to create the input data X and target labels y.

2. Define Input Data and Labels

X, y = np.array([[1, 2], [2, 3]]), np.array([0, 1])

X: This is the input feature matrix, where each row represents a sample and each column represents a feature. In this case, X is a 2x2 matrix:

X = [[1, 2],

     [2, 3]]

The first sample is [1, 2], and the second sample is [2, 3].

y: This is the target label array, where each element corresponds to the label of the respective sample in X. Here:

y = [0, 1]

The first sample ([1, 2]) has a label 0, and the second sample ([2, 3]) has a label 1.

3. Train the Decision Tree Classifier

clf = DecisionTreeClassifier().fit(X, y)

DecisionTreeClassifier(): This initializes a decision tree classifier object.

.fit(X, y): This method fits the decision tree model to the data X (input features) and y (target labels). During fitting, the decision tree algorithm learns the relationship between the features in X and the corresponding labels in y.

In this case, the decision tree will try to learn how to classify based on the two features. The decision tree algorithm works by recursively splitting the feature space into subsets based on feature values that provide the best separation between the classes (minimizing impurity like Gini impurity or entropy).

For such a small dataset, the decision tree will create a simple rule to separate the two samples based on their features:

It will notice that the first sample ([1, 2]) is labeled 0 and the second sample ([2, 3]) is labeled 1.

The tree will effectively create a rule to classify these two points correctly.

4. Make a Prediction

print(clf.predict([[2, 3]]))

clf.predict([[2, 3]]): This method is used to predict the class label for the input [[2, 3]]. This input is a new sample with features [2, 3], which is exactly the same as the second sample in the training data.

The model already knows that the second sample [2, 3] corresponds to the class 1 (from the training data). So, the decision tree will predict that the label for the input [2, 3] is 1.

The output of the code will be:

[1]

Read More